Built with doc-gen4, running Lean4. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑Ctrl+↓to navigate, Ctrl+🖱️to focus. On Mac, use Cmdinstead of Ctrl.
import Pretty.Defs.Basic
import Pretty.Supports.Pareto
import Pretty.Supports.MergeBasic

lemma 
merge_first_dom: ∀ {α : Type} {F : Factory α} {m₂ : Meas} {ms₂ : List Meas} {m₁ : Meas} (ms₁ : List Meas), pareto F (m₂ :: ms₂)dominates F m₁ m₂ = truen, merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true
merge_first_dom
(
ms₁: List Meas
ms₁
:
List: Type ?u.11 → Type ?u.11
List
Meas: {α : Type} → Type
Meas
) (
h_pareto₂: pareto F (m₂ :: ms₂)
h_pareto₂
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.8
F
(
m₂: ?m.22
m₂
::
ms₂: ?m.34
ms₂
)) (
h_dom: dominates F m₁ m₂ = true
h_dom
:
dominates: {α : Type} → Factory αMeasMeasBool
dominates
F: ?m.8
F
m₁: ?m.49
m₁
m₂: ?m.22
m₂
) : ∃
n: ?m.83
n
,
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.8
F
m₁: ?m.49
m₁
::
ms₁: List Meas
ms₁
,
m₂: ?m.22
m₂
::
ms₂: ?m.34
ms₂
⟩ =
m₁: ?m.49
m₁
::
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.8
F
ms₁: List Meas
ms₁
,
ms₂: ?m.34
ms₂
.
drop: {α : Type ?u.114} → List αList α
drop
n: ?m.83
n
⟩ ∧ ∀ (
m: Meas
m
:
Meas: {α : Type} → Type
Meas
),
m: Meas
m
ms₂: ?m.34
ms₂
.
take: {α : Type ?u.140} → List αList α
take
n: ?m.83
n
dominates: {α : Type} → Factory αMeasMeasBool
dominates
F: ?m.8
F
m₁: ?m.49
m₁
m: Meas
m
:=

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂: Meas

ms₂: List Meas

m₁: Meas

ms₁: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


n, merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]


nil
n, merge F (m₁ :: ms₁, [m₂]) = m₁ :: merge F (ms₁, List.drop n []) ∀ (m : Meas), m List.take n []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

head✝: Meas

tail✝: List Meas

tail_ih✝: pareto F (m₂ :: tail✝)n, merge F (m₁ :: ms₁, m₂ :: tail✝) = m₁ :: merge F (ms₁, List.drop n tail✝) ∀ (m : Meas), m List.take n tail✝dominates F m₁ m = true

h_pareto₂: pareto F (m₂ :: head✝ :: tail✝)


cons
n, merge F (m₁ :: ms₁, m₂ :: head✝ :: tail✝) = m₁ :: merge F (ms₁, List.drop n (head✝ :: tail✝)) ∀ (m : Meas), m List.take n (head✝ :: tail✝)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂: Meas

ms₂: List Meas

m₁: Meas

ms₁: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


n, merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]


n, merge F (m₁ :: ms₁, [m₂]) = m₁ :: merge F (ms₁, List.drop n []) ∀ (m : Meas), m List.take n []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]


merge F (m₁ :: ms₁, [m₂]) = m₁ :: merge F (ms₁, List.drop 0 []) ∀ (m : Meas), m List.take 0 []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]


n, merge F (m₁ :: ms₁, [m₂]) = m₁ :: merge F (ms₁, List.drop n []) ∀ (m : Meas), m List.take n []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]


nil
merge F ([m₁], [m₂]) = m₁ :: merge F ([], List.drop 0 []) ∀ (m : Meas), m List.take 0 []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]

head✝: Meas

tail✝: List Meas


cons
merge F (m₁ :: head✝ :: tail✝, [m₂]) = m₁ :: merge F (head✝ :: tail✝, List.drop 0 []) ∀ (m : Meas), m List.take 0 []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]


merge F (m₁ :: ms₁, [m₂]) = m₁ :: merge F (ms₁, List.drop 0 []) ∀ (m : Meas), m List.take 0 []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]


nil
merge F ([m₁], [m₂]) = m₁ :: merge F ([], List.drop 0 []) ∀ (m : Meas), m List.take 0 []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]

head✝: Meas

tail✝: List Meas


cons
merge F (m₁ :: head✝ :: tail✝, [m₂]) = m₁ :: merge F (head✝ :: tail✝, List.drop 0 []) ∀ (m : Meas), m List.take 0 []dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

h_pareto₂: pareto F [m₂]


merge F (m₁ :: ms₁, [m₂]) = m₁ :: merge F (ms₁, List.drop 0 []) ∀ (m : Meas), m List.take 0 []dominates F m₁ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂: Meas

ms₂: List Meas

m₁: Meas

ms₁: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


n, merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₂ :: tl)n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_pareto₂: pareto F (m₂ :: hd :: tl)


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₂ :: tl)n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_pareto₂: pareto F (m₂ :: hd :: tl)


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_dom✝: dominates F m₁ hd = true


first_dom
n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom✝: ¬dominates F m₁ hd = true

h_dom✝: dominates F hd m₁ = true


second_dom
n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁✝: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: m₁.last > hd.last


first_last
n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁✝: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


second_last
n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₂ :: tl)n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_pareto₂: pareto F (m₂ :: hd :: tl)


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_dom_hd: dominates F m₁ hd = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true


n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_dom_hd: dominates F m₁ hd = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_dom_hd: dominates F m₁ hd = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop (n + 1) (hd :: tl)) ∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_dom_hd: dominates F m₁ hd = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


left
merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop (n + 1) (hd :: tl))
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


right
∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_dom_hd: dominates F m₁ hd = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop (n + 1) (hd :: tl))

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_dom_hd: dominates F m₁ hd = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h: m List.take (n + 1) (hd :: tl)


dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h: m = hd m List.take n tl


dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h✝: m = hd


inl
dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h✝: m List.take n tl


inr
dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h: m = hd


dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

tl: List Meas

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h_pareto₂: pareto F (m₂ :: m :: tl)

h_dom_hd: dominates F m₁ m = true


dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

tl: List Meas

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h_pareto₂: pareto F (m₂ :: m :: tl)

h_dom_hd: dominates F m₁ m = true


dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h: m = hd


dominates F m₁ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true


∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_dom_hd: dominates F m₁ hd = true

ih: n, merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

n:

h_left: merge F (m₁ :: ms₁, tl) = m₁ :: merge F (ms₁, List.drop n tl)

h_right: ∀ (m : Meas), m List.take n tldominates F m₁ m = true

m: Meas

h: m List.take n tl


dominates F m₁ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₂ :: tl)n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_pareto₂: pareto F (m₂ :: hd :: tl)


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom: ¬dominates F m₁ hd = true

h_bad: dominates F hd m₁ = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom: ¬dominates F m₁ hd = true

h_bad: dominates F hd m₁ = true

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom: ¬dominates F m₁ hd = true

h_bad: dominates F hd m₁ = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom: ¬dominates F m₁ hd = true

h_bad: dominates F hd m₁ = true

h_pareto₂: hd.last < m₂.last Factory.lt F m₂.cost hd.cost


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom: ¬dominates F m₁ hd = true

h_bad: dominates F hd m₁ = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom: ¬dominates F m₁ hd = true

h_pareto₂: hd.last < m₂.last Factory.lt F m₂.cost hd.cost

h_bad: hd.last m₁.last Factory.le F hd.cost m₁.cost = true

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom: ¬dominates F m₁ hd = true

h_bad: dominates F hd m₁ = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₂ :: tl)n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_pareto₂: pareto F (m₂ :: hd :: tl)


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂: ¬dominates F hd m₁ = true

h_last: m₁.last > hd.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂: ¬dominates F hd m₁ = true

h_last: m₁.last > hd.last


n, merge F (ms₁, hd :: tl) = merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂: ¬dominates F hd m₁ = true

h_last: m₁.last > hd.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂: ¬dominates F hd m₁ = true

h_last: m₁.last > hd.last


merge F (ms₁, hd :: tl) = merge F (ms₁, List.drop 0 (hd :: tl)) ∀ (m : Meas), m List.take 0 (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂: ¬dominates F hd m₁ = true

h_last: m₁.last > hd.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₂ :: tl)n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_pareto₂: pareto F (m₂ :: hd :: tl)


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: m₁.last hd.lastFactory.le F m₁.cost hd.cost = false


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: m₁.last hd.lastFactory.le F m₁.cost hd.cost = false


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: m₁.last hd.lastFactory.le F m₁.cost hd.cost = false


m₁.last hd.last
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: m₁.last hd.lastFactory.le F m₁.cost hd.cost = false


m₁.last hd.last
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: m₁.last hd.lastFactory.le F m₁.cost hd.cost = false


m₁.last hd.last
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: m₁.last hd.lastFactory.le F m₁.cost hd.cost = false


h
m₁.last < hd.last
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: m₁.last hd.lastFactory.le F m₁.cost hd.cost = false


m₁.last hd.last

Goals accomplished! 🐙

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.le F m₁.cost hd.cost = false


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.le F m₁.cost hd.cost = false

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.le F m₁.cost hd.cost = false

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, ¬Factory.le F c₁ c₂ = true Factory.lt F c₂ c₁


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.le F m₁.cost hd.cost = false

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.le F m₁.cost hd.cost = false

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: Factory.lt F m₂.cost m₁.cost


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: Factory.lt F m₂.cost m₁.cost


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: ¬Factory.le F m₁.cost m₂.cost = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: ¬Factory.le F m₁.cost m₂.cost = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: ¬Factory.le F m₁.cost m₂.cost = true


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last

h_dom: m₁.last m₂.last Factory.le F m₁.cost m₂.cost = true

h_non_dom₁: Factory.lt F hd.cost m₁.cost

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: False


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true
α✝: Type

F: Factory α✝

m₂, m₁: Meas

ms₁: List Meas

h_dom: dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₂: pareto F (m₂ :: hd :: tl)

ih: n, merge F (m₁ :: ms₁, m₂ :: tl) = m₁ :: merge F (ms₁, List.drop n tl) ∀ (m : Meas), m List.take n tldominates F m₁ m = true

h_non_dom₁: ¬dominates F m₁ hd = true

h_non_dom₂✝: ¬dominates F hd m₁ = true

h✝: hd.last > m₁.last


n, merge F (m₁ :: ms₁, m₂ :: hd :: tl) = m₁ :: merge F (ms₁, List.drop n (hd :: tl)) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₁ m = true

Goals accomplished! 🐙
lemma
merge_second_dom: ∀ {α : Type} {F : Factory α} {m₁ : Meas} {ms₁ : List Meas} {m₂ : Meas} (ms₂ : List Meas), pareto F (m₁ :: ms₁)dominates F m₂ m₁ = true¬dominates F m₁ m₂ = truen, merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true
merge_second_dom
(
ms₂: List Meas
ms₂
:
List: Type ?u.24331 → Type ?u.24331
List
Meas: {α : Type} → Type
Meas
) (
h_pareto₁: pareto F (m₁ :: ms₁)
h_pareto₁
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.24314
F
(
m₁: ?m.24328
m₁
::
ms₁: ?m.24340
ms₁
)) (
h_dom: dominates F m₂ m₁ = true
h_dom
:
dominates: {α : Type} → Factory αMeasMeasBool
dominates
F: ?m.24314
F
m₂: ?m.24355
m₂
m₁: ?m.24328
m₁
) (
h_non_dom: ¬dominates F m₁ m₂ = true
h_non_dom
: ¬
dominates: {α : Type} → Factory αMeasMeasBool
dominates
F: ?m.24314
F
m₁: ?m.24328
m₁
m₂: ?m.24355
m₂
) : ∃
n: ?m.24471
n
, (
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.24314
F
m₁: ?m.24328
m₁
::
ms₁: ?m.24340
ms₁
,
m₂: ?m.24355
m₂
::
ms₂: List Meas
ms₂
⟩) =
m₂: ?m.24355
m₂
:: (
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.24314
F
ms₁: ?m.24340
ms₁
.
drop: {α : Type ?u.24502} → List αList α
drop
n: ?m.24471
n
,
ms₂: List Meas
ms₂
⟩) ∧ ∀ (
m: Meas
m
:
Meas: {α : Type} → Type
Meas
),
m: Meas
m
ms₁: ?m.24340
ms₁
.
take: {α : Type ?u.24528} → List αList α
take
n: ?m.24471
n
dominates: {α : Type} → Factory αMeasMeasBool
dominates
F: ?m.24314
F
m₂: ?m.24355
m₂
m: Meas
m
:=

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true


n, merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

h_pareto₁: pareto F [m₁]


nil
n, merge F ([m₁], m₂ :: ms₂) = m₂ :: merge F (List.drop n [], ms₂) ∀ (m : Meas), m List.take n []dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

head✝: Meas

tail✝: List Meas

tail_ih✝: pareto F (m₁ :: tail✝)n, merge F (m₁ :: tail✝, m₂ :: ms₂) = m₂ :: merge F (List.drop n tail✝, ms₂) ∀ (m : Meas), m List.take n tail✝dominates F m₂ m = true

h_pareto₁: pareto F (m₁ :: head✝ :: tail✝)


cons
n, merge F (m₁ :: head✝ :: tail✝, m₂ :: ms₂) = m₂ :: merge F (List.drop n (head✝ :: tail✝), ms₂) ∀ (m : Meas), m List.take n (head✝ :: tail✝)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true


n, merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

h_pareto₁: pareto F [m₁]


n, merge F ([m₁], m₂ :: ms₂) = m₂ :: merge F (List.drop n [], ms₂) ∀ (m : Meas), m List.take n []dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

h_pareto₁: pareto F [m₁]


merge F ([m₁], m₂ :: ms₂) = m₂ :: merge F (List.drop 0 [], ms₂) ∀ (m : Meas), m List.take 0 []dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

h_pareto₁: pareto F [m₁]


n, merge F ([m₁], m₂ :: ms₂) = m₂ :: merge F (List.drop n [], ms₂) ∀ (m : Meas), m List.take n []dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

h_pareto₁: pareto F [m₁]


dominates F m₁ m₂ = truemerge F ([m₁], ms₂) = m₂ :: ms₂
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

h_pareto₁: pareto F [m₁]


n, merge F ([m₁], m₂ :: ms₂) = m₂ :: merge F (List.drop n [], ms₂) ∀ (m : Meas), m List.take n []dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

h_pareto₁: pareto F [m₁]

a✝: dominates F m₁ m₂ = true


merge F ([m₁], ms₂) = m₂ :: ms₂
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

h_pareto₁: pareto F [m₁]


n, merge F ([m₁], m₂ :: ms₂) = m₂ :: merge F (List.drop n [], ms₂) ∀ (m : Meas), m List.take n []dominates F m₂ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true


n, merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₁ :: tl)n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_pareto₁: pareto F (m₁ :: hd :: tl)


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₁ :: tl)n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_pareto₁: pareto F (m₁ :: hd :: tl)


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_dom✝: dominates F hd m₂ = true


first_dom
n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom✝: ¬dominates F hd m₂ = true

h_dom✝: dominates F m₂ hd = true


second_dom
n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁✝: ¬dominates F hd m₂ = true

h_non_dom₂✝: ¬dominates F m₂ hd = true

h✝: hd.last > m₂.last


first_last
n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁✝: ¬dominates F hd m₂ = true

h_non_dom₂✝: ¬dominates F m₂ hd = true

h✝: m₂.last > hd.last


second_last
n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₁ :: tl)n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_pareto₁: pareto F (m₁ :: hd :: tl)


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_bad: dominates F hd m₂ = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_bad: dominates F hd m₂ = true

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_bad: dominates F hd m₂ = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h_bad: hd.last m₂.last Factory.le F hd.cost m₂.cost = true

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_bad: dominates F hd m₂ = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₁ :: tl)n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_pareto₁: pareto F (m₁ :: hd :: tl)


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true


n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop (n + 1) (hd :: tl), ms₂) ∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


left
merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop (n + 1) (hd :: tl), ms₂)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


right
∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop (n + 1) (hd :: tl), ms₂)

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


∀ (a : Meas), a List.take n tldominates F m₂ a = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true

m: Meas

h: m List.take n tl


dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

h_non_dom_hd: ¬dominates F hd m₂ = true

h_dom_hd: dominates F m₂ hd = true

ih: n, merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

n:

h_left: merge F (tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂)

h_right: ∀ (m : Meas), m List.take n tldominates F m₂ m = true


∀ (m : Meas), m List.take (n + 1) (hd :: tl)dominates F m₂ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₁ :: tl)n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_pareto₁: pareto F (m₁ :: hd :: tl)


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: m₂.last hd.lastFactory.le F m₂.cost hd.cost = false


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: m₂.last hd.lastFactory.le F m₂.cost hd.cost = false


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: m₂.last hd.lastFactory.le F m₂.cost hd.cost = false


m₂.last hd.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: m₂.last hd.lastFactory.le F m₂.cost hd.cost = false


m₂.last hd.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: m₂.last hd.lastFactory.le F m₂.cost hd.cost = false


m₂.last hd.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: m₂.last hd.lastFactory.le F m₂.cost hd.cost = false


h
m₂.last < hd.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: m₂.last hd.lastFactory.le F m₂.cost hd.cost = false


m₂.last hd.last

Goals accomplished! 🐙

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.le F m₂.cost hd.cost = false


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.le F m₂.cost hd.cost = false

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.le F m₂.cost hd.cost = false

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, ¬Factory.le F c₁ c₂ = true Factory.lt F c₂ c₁


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.le F m₂.cost hd.cost = false

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.le F m₂.cost hd.cost = false

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: Factory.lt F m₁.cost m₂.cost


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: Factory.lt F m₁.cost m₂.cost


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: ¬Factory.le F m₂.cost m₁.cost = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: ¬Factory.le F m₂.cost m₁.cost = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: ¬Factory.le F m₂.cost m₁.cost = true


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_last: hd.last > m₂.last

h_dom: m₂.last m₁.last Factory.le F m₂.cost m₁.cost = true

h_non_dom₂: Factory.lt F hd.cost m₂.cost

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h': ∀ {c₁ c₂ : α✝}, Factory.le F c₁ c₂ = false Factory.lt F c₂ c₁

h_trans: False


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: hd.last > m₂.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

ih: pareto F (m₁ :: tl)n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_pareto₁: pareto F (m₁ :: hd :: tl)


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: m₂.last > hd.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: ¬m₂.last < hd.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: m₂.last > hd.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: ¬m₂.last < hd.last


n, merge F (hd :: tl, ms₂) = merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: m₂.last > hd.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: ¬m₂.last < hd.last


merge F (hd :: tl, ms₂) = merge F (List.drop 0 (hd :: tl), ms₂) ∀ (m : Meas), m List.take 0 (hd :: tl)dominates F m₂ m = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_dom: dominates F m₂ m₁ = true

h_non_dom: ¬dominates F m₁ m₂ = true

hd: Meas

tl: List Meas

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih: n, merge F (m₁ :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n tl, ms₂) ∀ (m : Meas), m List.take n tldominates F m₂ m = true

h_non_dom₁: ¬dominates F hd m₂ = true

h_non_dom₂: ¬dominates F m₂ hd = true

h_last: m₂.last > hd.last


n, merge F (m₁ :: hd :: tl, m₂ :: ms₂) = m₂ :: merge F (List.drop n (hd :: tl), ms₂) ∀ (m : Meas), m List.take n (hd :: tl)dominates F m₂ m = true

Goals accomplished! 🐙
lemma
merge_head_either: ∀ {α : Type} {F : Factory α} {m₁ : Meas} {ms₁ : List Meas} {m₂ : Meas} {ms₂ : List Meas}, pareto F (m₁ :: ms₁)pareto F (m₂ :: ms₂)m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
merge_head_either
(
h_pareto₁: pareto F (m₁ :: ms₁)
h_pareto₁
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.49607
F
(
m₁: ?m.49617
m₁
::
ms₁: ?m.49625
ms₁
)) (
h_pareto₂: pareto F (m₂ :: ms₂)
h_pareto₂
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.49607
F
(
m₂: ?m.49638
m₂
::
ms₂: ?m.49651
ms₂
)) :
m₁: ?m.49617
m₁
=
List.head: {α : Type ?u.49666} → (as : List α) → as []α
List.head
(
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.49607
F
m₁: ?m.49617
m₁
::
ms₁: ?m.49625
ms₁
,
m₂: ?m.49638
m₂
::
ms₂: ?m.49651
ms₂
⟩) (

Goals accomplished! 🐙
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


merge F (m₁ :: ms₁, m₂ :: ms₂) []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


merge F (m₁ :: ms₁, m₂ :: ms₂) []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


merge F (m₁ :: ms₁, m₂ :: ms₂) []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


h
m₁ :: ms₁ [] m₂ :: ms₂ []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


h
m₁ :: ms₁ [] m₂ :: ms₂ []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


merge F (m₁ :: ms₁, m₂ :: ms₂) []

Goals accomplished! 🐙

Goals accomplished! 🐙
) ∨
m₂: ?m.49638
m₂
=
List.head: {α : Type ?u.49687} → (as : List α) → as []α
List.head
(
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.49607
F
m₁: ?m.49617
m₁
::
ms₁: ?m.49625
ms₁
,
m₂: ?m.49638
m₂
::
ms₂: ?m.49651
ms₂
⟩) (

Goals accomplished! 🐙
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


merge F (m₁ :: ms₁, m₂ :: ms₂) []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


merge F (m₁ :: ms₁, m₂ :: ms₂) []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


merge F (m₁ :: ms₁, m₂ :: ms₂) []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


h
m₁ :: ms₁ [] m₂ :: ms₂ []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


h
m₁ :: ms₁ [] m₂ :: ms₂ []
F: Factory ?m.49655

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


merge F (m₁ :: ms₁, m₂ :: ms₂) []

Goals accomplished! 🐙

Goals accomplished! 🐙
) :=

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom✝: dominates F m₁ m₂ = true


first_dom
m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom✝: ¬dominates F m₁ m₂ = true

h_dom✝: dominates F m₂ m₁ = true


second_dom
m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₁.last > m₂.last


first_last
m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


second_last
m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


h
m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


h
m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


h
m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


h
m₁ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


h
m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


h
m₁ = List.get ?m.50375 { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length ?m.50375) }
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


h.h
merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.50375
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


List Meas
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


h
m₁ = List.get ?m.50375 { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length ?m.50375) }
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


h.h
merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.50375
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


List Meas
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.50375

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop w✝ ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₂dominates F m₁ m = true


m₁ = List.get (m₁ :: merge F (ms₁, List.drop w✝ ms₂)) { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length (m₁ :: merge F (ms₁, List.drop w✝ ms₂))) }

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


h
m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


h
m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


h
m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


h
m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


h
m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


h
m₂ = List.get ?m.50797 { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length ?m.50797) }
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


h.h
merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.50797
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


List Meas
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


h
m₂ = List.get ?m.50797 { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length ?m.50797) }
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


h.h
merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.50797
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


List Meas
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.50797

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

w✝:

left✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop w✝ ms₁, ms₂)

right✝: ∀ (m : Meas), m List.take w✝ ms₁dominates F m₂ m = true


m₂ = List.get (m₂ :: merge F (List.drop w✝ ms₁, ms₂)) { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length (m₂ :: merge F (List.drop w✝ ms₁, ms₂))) }

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₁.last > m₂.last


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


¬m₁.last > m₂.last

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) []) m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])

Goals accomplished! 🐙

Goals accomplished! 🐙
lemma
merge_preserves_pareto: ∀ {α : Type} {F : Factory α} {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))
merge_preserves_pareto
(
h_pareto₁: pareto F ms₁
h_pareto₁
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.53466
F
ms₁: ?m.53473
ms₁
) (
h_pareto₂: pareto F ms₂
h_pareto₂
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.53466
F
ms₂: ?m.53483
ms₂
) :
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.53466
F
(
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.53466
F
ms₁: ?m.53473
ms₁
,
ms₂: ?m.53483
ms₂
⟩) :=

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂


pareto F (merge F (ms₁, ms₂))
α✝: Type

F: Factory α✝

ms₂: List Meas

h_pareto₁: pareto F []

h_pareto₂: pareto F ms₂


nil
pareto F (merge F ([], ms₂))
α✝: Type

F: Factory α✝

head✝: Meas

tail✝: List Meas

tail_ih✝: ∀ {ms₂ : List Meas}, pareto F tail✝pareto F ms₂pareto F (merge F (tail✝, ms₂))

ms₂: List Meas

h_pareto₁: pareto F (head✝ :: tail✝)

h_pareto₂: pareto F ms₂


cons
pareto F (merge F (head✝ :: tail✝, ms₂))
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂


pareto F (merge F (ms₁, ms₂))
α✝: Type

F: Factory α✝

ms₂: List Meas

h_pareto₁: pareto F []

h_pareto₂: pareto F ms₂


pareto F (merge F ([], ms₂))

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂


pareto F (merge F (ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F ms₂


pareto F (merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []


nil
pareto F (merge F (m₁ :: ms₁, []))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

head✝: Meas

tail✝: List Meas

tail_ih✝: pareto F tail✝pareto F (merge F (m₁ :: ms₁, tail✝))

h_pareto₂: pareto F (head✝ :: tail✝)


cons
pareto F (merge F (m₁ :: ms₁, head✝ :: tail✝))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F ms₂


pareto F (merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []


pareto F (merge F (m₁ :: ms₁, []))

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

ms₂: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F ms₂


pareto F (merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)


pareto F (merge F (m₁ :: ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)


pareto F (merge F (m₁ :: ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom✝: dominates F m₁ m₂ = true


first_dom
pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom✝: ¬dominates F m₁ m₂ = true

h_dom✝: dominates F m₂ m₁ = true


second_dom
pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₁.last > m₂.last


first_last
pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


second_last
pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)


pareto F (merge F (m₁ :: ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


pareto F (merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


pareto F ms₂
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


h
pareto F (?m :: ms₂)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


m
Meas
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)


pareto F (merge F (m₁ :: ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


pareto F (merge F (ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


pareto F (merge F (ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


h_pareto₁
pareto F ms₁
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


h_pareto₂
pareto F (m₂ :: ms₂)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


h_pareto₁
pareto F ms₁
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


pareto F ms₁
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


h
pareto F (?m :: ms₁)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m
Meas
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


pareto F ms₁

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)


pareto F (merge F (m₁ :: ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


pareto F (m₁ :: merge F (ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


nil
pareto F (m₁ :: merge F ([], m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

head✝: Meas

tail✝: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (head✝ :: tail✝)pareto F ms₂pareto F (merge F (head✝ :: tail✝, ms₂))

h_pareto₁: pareto F (m₁ :: head✝ :: tail✝)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: head✝ :: tail✝, ms₂))


cons
pareto F (m₁ :: merge F (head✝ :: tail✝, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


pareto F (m₁ :: merge F ([], m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


pareto F (m₁ :: m₂ :: ms₂)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


pareto F (m₁ :: merge F ([], m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


pareto F (m₁ :: m₂ :: ms₂)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


h_last
m₁.last > m₂.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


h_cost
Factory.lt F m₁.cost m₂.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


h
pareto F (m₂ :: ms₂)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


h_cost
Factory.lt F m₁.cost m₂.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


pareto F (m₁ :: merge F ([], m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


Factory.lt F m₁.cost m₂.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


Factory.lt F m₁.cost m₂.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


¬Factory.le F m₂.cost m₁.cost = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


¬Factory.le F m₂.cost m₁.cost = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


Factory.lt F m₁.cost m₂.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))

h_non_dom₂: m₂.last m₁.lastFactory.le F m₂.cost m₁.cost = false


¬Factory.le F m₂.cost m₁.cost = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

ih₁: ∀ {ms₂ : List Meas}, pareto F []pareto F ms₂pareto F (merge F ([], ms₂))

h_pareto₁: pareto F [m₁]

ih₂: pareto F ms₂pareto F (merge F ([m₁], ms₂))


Factory.lt F m₁.cost m₂.cost

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))


pareto F (m₁ :: merge F (hd :: tl, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

h_merge: merge F (hd :: tl, m₂ :: ms₂) = []


nil
pareto F [m₁]
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


cons
pareto F (m₁ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))


pareto F (m₁ :: merge F (hd :: tl, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

h_merge: merge F (hd :: tl, m₂ :: ms₂) = []


pareto F [m₁]

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))


pareto F (m₁ :: merge F (hd :: tl, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (m₁ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


h_last
m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


h_cost
Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


h
pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (m₁ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h✝: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


inl
m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h✝: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


inr
m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h: hd = head✝


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

tail✝: List Meas

h_pareto₁': pareto F (hd :: tl)

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h_merge: merge F (hd :: tl, m₂ :: ms₂) = hd :: tail✝


m₁.last > hd.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


m₁.last > head✝.last

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = head✝


m₁.last > head✝.last
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


m₁.last > head✝.last

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (m₁ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h✝: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


inl
Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h✝: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


inr
Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h: hd = head✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h_pareto₁: m₁.last > hd.last Factory.lt F m₁.cost hd.cost

h: hd = head✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h_pareto₁: m₁.last > head✝.last Factory.lt F m₁.cost head✝.cost

h: hd = head✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h_pareto₁: m₁.last > head✝.last Factory.lt F m₁.cost head✝.cost

h: hd = head✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h_pareto₁: m₁.last > head✝.last Factory.lt F m₁.cost head✝.cost

h: hd = head✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: hd = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


¬Factory.le F head✝.cost m₁.cost = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


¬Factory.le F head✝.cost m₁.cost = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = head✝


¬Factory.le F head✝.cost m₁.cost = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

tail✝: List Meas

h_pareto₁': pareto F (hd :: tl)

h_merge: merge F (hd :: tl, m₂ :: ms₂) = m₂ :: tail✝


¬Factory.le F m₂.cost m₁.cost = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

tail✝: List Meas

h_pareto₁': pareto F (hd :: tl)

h_merge: merge F (hd :: tl, m₂ :: ms₂) = m₂ :: tail✝

h_non_dom₂: m₂.last m₁.lastFactory.le F m₂.cost m₁.cost = false


¬Factory.le F m₂.cost m₁.cost = true
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝

h_pareto₁': pareto F (hd :: tl)

h: m₂ = List.head (merge F (hd :: tl, m₂ :: ms₂)) (_ : merge F (hd :: tl, m₂ :: ms₂) [])


Factory.lt F m₁.cost head✝.cost

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (m₁ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (merge F (hd :: tl, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (merge F (hd :: tl, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (merge F (hd :: tl, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


h_pareto₁
pareto F (hd :: tl)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


h_pareto₂
pareto F (m₂ :: ms₂)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


h_pareto₁
pareto F (hd :: tl)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (hd :: tl)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


h
pareto F (?m :: hd :: tl)
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


m
Meas
α✝: Type

F: Factory α✝

m₁, m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F (hd :: tl)pareto F ms₂pareto F (merge F (hd :: tl, ms₂))

h_pareto₁: pareto F (m₁ :: hd :: tl)

ih₂: pareto F ms₂pareto F (merge F (m₁ :: hd :: tl, ms₂))

head✝: Meas

tail✝: List Meas

h_merge: merge F (hd :: tl, m₂ :: ms₂) = head✝ :: tail✝


pareto F (hd :: tl)

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)


pareto F (merge F (m₁ :: ms₁, m₂ :: ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


¬m₁.last > m₂.last

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last


pareto F (m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


nil
pareto F (m₂ :: merge F (m₁ :: ms₁, []))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

head✝: Meas

tail✝: List Meas

ih₂: pareto F (head✝ :: tail✝)pareto F (merge F (m₁ :: ms₁, head✝ :: tail✝))

h_pareto₂: pareto F (m₂ :: head✝ :: tail✝)


cons
pareto F (m₂ :: merge F (m₁ :: ms₁, head✝ :: tail✝))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


pareto F (m₂ :: merge F (m₁ :: ms₁, []))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


pareto F (m₂ :: m₁ :: ms₁)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


pareto F (m₂ :: merge F (m₁ :: ms₁, []))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


pareto F (m₂ :: m₁ :: ms₁)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


h_last
m₂.last > m₁.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


h_cost
Factory.lt F m₂.cost m₁.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


h
pareto F (m₁ :: ms₁)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


h_cost
Factory.lt F m₂.cost m₁.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


pareto F (m₂ :: merge F (m₁ :: ms₁, []))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


Factory.lt F m₂.cost m₁.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


Factory.lt F m₂.cost m₁.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


¬Factory.le F m₁.cost m₂.cost = true
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


¬Factory.le F m₁.cost m₂.cost = true
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


Factory.lt F m₂.cost m₁.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]

h_non_dom₁: m₁.last m₂.lastFactory.le F m₁.cost m₂.cost = false


¬Factory.le F m₁.cost m₂.cost = true
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

ih₂: pareto F []pareto F (merge F (m₁ :: ms₁, []))

h_pareto₂: pareto F [m₂]


Factory.lt F m₂.cost m₁.cost

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

ih₂: pareto F ms₂pareto F (merge F (m₁ :: ms₁, ms₂))

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


pareto F (if dominates F m₁ m₂ = true then merge F (m₁ :: ms₁, ms₂) else if dominates F m₂ m₁ = true then merge F (ms₁, m₂ :: ms₂) else if m₂.last < m₁.last then m₁ :: merge F (ms₁, m₂ :: ms₂) else m₂ :: merge F (m₁ :: ms₁, ms₂))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)


pareto F (m₂ :: merge F (m₁ :: ms₁, hd :: tl))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_merge: merge F (m₁ :: ms₁, hd :: tl) = []


nil
pareto F [m₂]
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


cons
pareto F (m₂ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)


pareto F (m₂ :: merge F (m₁ :: ms₁, hd :: tl))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

h_merge: merge F (m₁ :: ms₁, hd :: tl) = []


pareto F [m₂]

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)


pareto F (m₂ :: merge F (m₁ :: ms₁, hd :: tl))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (m₂ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


h_last
m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


h_cost
Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


h
pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (m₂ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h✝: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


inl
m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h✝: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


inr
m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = head✝


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


m₂.last > head✝.last

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = head✝


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

tail✝: List Meas

h_pareto₂': pareto F (hd :: tl)

h_merge: merge F (m₁ :: ms₁, hd :: tl) = hd :: tail✝


m₂.last > hd.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


m₂.last > head✝.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

tail✝: List Meas

h_pareto₂': pareto F (hd :: tl)

h_merge: merge F (m₁ :: ms₁, hd :: tl) = hd :: tail✝

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost


m₂.last > hd.last
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


m₂.last > head✝.last

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (m₂ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h✝: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


inl
Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h✝: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


inr
Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


¬Factory.le F head✝.cost m₂.cost = true
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


¬Factory.le F head✝.cost m₂.cost = true
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = head✝


¬Factory.le F head✝.cost m₂.cost = true
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = head✝


Factory.le F m₁.cost m₂.cost = false
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = head✝

h_non_dom₁: m₁.last m₂.lastFactory.le F m₁.cost m₂.cost = false


Factory.le F m₁.cost m₂.cost = false
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: m₁ = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = head✝


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

tail✝: List Meas

h_pareto₂': pareto F (hd :: tl)

h_merge: merge F (m₁ :: ms₁, hd :: tl) = hd :: tail✝


Factory.lt F m₂.cost hd.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

tail✝: List Meas

h_pareto₂': pareto F (hd :: tl)

h_merge: merge F (m₁ :: ms₁, hd :: tl) = hd :: tail✝

h_pareto₂: m₂.last > hd.last Factory.lt F m₂.cost hd.cost


Factory.lt F m₂.cost hd.cost
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝

h_pareto₂': pareto F (hd :: tl)

h: hd = List.head (merge F (m₁ :: ms₁, hd :: tl)) (_ : merge F (m₁ :: ms₁, hd :: tl) [])


Factory.lt F m₂.cost head✝.cost

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (m₂ :: head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (merge F (m₁ :: ms₁, hd :: tl))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (merge F (m₁ :: ms₁, hd :: tl))
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (hd :: tl)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (head✝ :: tail✝)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


h
pareto F (?m :: hd :: tl)
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


m
Meas
α✝: Type

F: Factory α✝

m₁: Meas

ms₁: List Meas

ih₁: ∀ {ms₂ : List Meas}, pareto F ms₁pareto F ms₂pareto F (merge F (ms₁, ms₂))

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

hd: Meas

tl: List Meas

ih₂: pareto F (hd :: tl)pareto F (merge F (m₁ :: ms₁, hd :: tl))

h_pareto₂: pareto F (m₂ :: hd :: tl)

head✝: Meas

tail✝: List Meas

h_merge: merge F (m₁ :: ms₁, hd :: tl) = head✝ :: tail✝


pareto F (head✝ :: tail✝)

Goals accomplished! 🐙
lemma
merge_pareto_subset: ∀ {α : Type} {m : Meas} {F : Factory α} {ms₁ ms₂ : List Meas}, m merge F (ms₁, ms₂)pareto F ms₁pareto F ms₂m ms₁ m ms₂
merge_pareto_subset
(
h_in: m merge F (ms₁, ms₂)
h_in
:
m: ?m.64633
m
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.64653
F
ms₁: ?m.64685
ms₁
,
ms₂: ?m.64714
ms₂
⟩) (
h_pareto₁: pareto F ms₁
h_pareto₁
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.64653
F
ms₁: ?m.64685
ms₁
) (
h_pareto₂: pareto F ms₂
h_pareto₂
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.64653
F
ms₂: ?m.64714
ms₂
) :
m: ?m.64633
m
ms₁: ?m.64685
ms₁
m: ?m.64633
m
ms₂: ?m.64714
ms₂
:=

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

ms₁, ms₂: List Meas

h_in: m merge F (ms₁, ms₂)

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

ms₁, ms₂: List Meas

h_in: m merge F (ms₁, ms₂)

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

ms₁, ms₂: List Meas

h_in: m merge F (ms₁, ms₂)

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

rms: List Meas

h: merge F (ms₁, ms₂) = rms

h_in: m rms


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

ms₁, ms₂: List Meas

h_in: m merge F (ms₁, ms₂)

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

rms: List Meas

h: merge F (ms₁, ms₂) = rms

h_in: m rms


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = []

h_in: m []


nil
m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

head✝: Meas

tail✝: List Meas

tail_ih✝: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tail✝m tail✝m ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = head✝ :: tail✝

h_in: m head✝ :: tail✝


cons
m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

head✝: Meas

tail✝: List Meas

tail_ih✝: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tail✝m tail✝m ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = head✝ :: tail✝

h_in: m head✝ :: tail✝


cons
m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

ms₁, ms₂: List Meas

h_in: m merge F (ms₁, ms₂)

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = hd :: tl

h_in: m hd :: tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = m :: tl


head
m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = hd :: tl

a✝: List.Mem m tl


tail
m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = hd :: tl

h_in: m hd :: tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = m :: tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h_pareto₁: pareto F []

h: merge F ([], ms₂) = m :: tl


nil
m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

head✝: Meas

tail✝: List Meas

h_pareto₁: pareto F (head✝ :: tail✝)

h: merge F (head✝ :: tail✝, ms₂) = m :: tl


cons
m head✝ :: tail✝ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = m :: tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h_pareto₁: pareto F []

h: merge F ([], ms₂) = m :: tl


m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h_pareto₁: pareto F []

h: ms₂ = m :: tl


m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h_pareto₁: pareto F []

h: merge F ([], ms₂) = m :: tl


m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h_pareto₁: pareto F []

h_pareto₂: pareto F (m :: tl)


m [] m m :: tl
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h_pareto₁: pareto F []

h: merge F ([], ms₂) = m :: tl


m [] m ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = m :: tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: merge F (m₁ :: ms₁, ms₂) = m :: tl


m m₁ :: ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = m :: tl


nil
m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

head✝: Meas

tail✝: List Meas

h_pareto₂: pareto F (head✝ :: tail✝)

h: merge F (m₁ :: ms₁, head✝ :: tail✝) = m :: tl


cons
m m₁ :: ms₁ m head✝ :: tail✝
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: merge F (m₁ :: ms₁, ms₂) = m :: tl


m m₁ :: ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = m :: tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: m₁ = m ms₁ = tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = m :: tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

hl: m₁ = m


intro
m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = m :: tl


m m₁ :: ms₁ m []
α✝: Type

F: Factory α✝

tl: List Meas

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm₁ tlm₁ ms₁ m₁ ms₂


intro
m₁ m₁ :: ms₁ m₁ []
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = m :: tl


m m₁ :: ms₁ m []

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: merge F (m₁ :: ms₁, ms₂) = m :: tl


m m₁ :: ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₂ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h'✝: m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }

h': m₂ = List.get ?m.72616 { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length ?m.72616) }


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }


inr.h
merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.72616
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }


List Meas
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h'✝: m₁ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }

h': m₁ = List.get ?m.69393 { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length ?m.69393) }


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₁ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }


inl.h
merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.69393
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₁ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }


List Meas
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h'✝: m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }

h': m₂ = List.get ?m.72616 { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length ?m.72616) }


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }


inr.h
merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.72616
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }


List Meas
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h': m₁ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }


merge F (m₁ :: ms₁, m₂ :: ms₂) = ?m.69393

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h✝: m₁ = List.head (merge F (m₁ :: ms₁, m₂ :: ms₂)) (_ : merge F (m₁ :: ms₁, m₂ :: ms₂) [])


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h'✝: m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }

h': m₂ = List.get (m :: tl) { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length (m :: tl)) }


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h'✝: m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }

h': m₂ = m


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h'✝: m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }

h': m₂ = List.get (m :: tl) { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length (m :: tl)) }


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

F: Factory α✝

tl: List Meas

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h': m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm₂ tlm₂ ms₁ m₂ ms₂

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: tl


inr
m₂ m₁ :: ms₁ m₂ m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = m :: tl

h'✝: m₂ = List.get (merge F (m₁ :: ms₁, m₂ :: ms₂)) { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }

h': m₂ = List.get (m :: tl) { val := { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) }, isLt := (_ : { val := 0, isLt := (_ : 0 < List.length (merge F (m₁ :: ms₁, m₂ :: ms₂))) } < List.length (m :: tl)) }


inr
m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = hd :: tl

h_in: m hd :: tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = hd :: tl

h': List.Mem m tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h: merge F ([], ms₂) = hd :: tl


nil
m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

head✝: Meas

tail✝: List Meas

h_pareto₁: pareto F (head✝ :: tail✝)

h: merge F (head✝ :: tail✝, ms₂) = hd :: tl


cons
m head✝ :: tail✝ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = hd :: tl

h': List.Mem m tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h: merge F ([], ms₂) = hd :: tl


m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h: ms₂ = hd :: tl


m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h: merge F ([], ms₂) = hd :: tl


m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h_pareto₂: pareto F (hd :: tl)


m [] m hd :: tl
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h: merge F ([], ms₂) = hd :: tl


m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h_pareto₂: pareto F (hd :: tl)


m = hd m tl
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h: merge F ([], ms₂) = hd :: tl


m [] m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h_pareto₂: pareto F (hd :: tl)


h
m tl
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

h_pareto₁: pareto F []

h: merge F ([], ms₂) = hd :: tl


m [] m ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: merge F (ms₁, ms₂) = hd :: tl

h': List.Mem m tl


m ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m m₁ :: ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = hd :: tl


nil
m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

head✝: Meas

tail✝: List Meas

h_pareto₂: pareto F (head✝ :: tail✝)

h: merge F (m₁ :: ms₁, head✝ :: tail✝) = hd :: tl


cons
m m₁ :: ms₁ m head✝ :: tail✝
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m m₁ :: ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = hd :: tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: m₁ = hd ms₁ = tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = hd :: tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: m₁ = hd ms₁ = tl

h₁: m₁ = hd

h₂: ms₁ = tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = hd :: tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

ih: ∀ {ms₁_1 ms₂ : List Meas}, pareto F ms₁_1pareto F ms₂merge F (ms₁_1, ms₂) = ms₁m ms₁m ms₁_1 m ms₂

h': List.Mem m ms₁

h: m₁ = m₁ ms₁ = ms₁


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = hd :: tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

ih: ∀ {ms₁_1 ms₂ : List Meas}, pareto F ms₁_1pareto F ms₂merge F (ms₁_1, ms₂) = ms₁m ms₁m ms₁_1 m ms₂

h': List.Mem m ms₁

h: m₁ = m₁ ms₁ = ms₁


m = m₁ m ms₁
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = hd :: tl


m m₁ :: ms₁ m []
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

ih: ∀ {ms₁_1 ms₂ : List Meas}, pareto F ms₁_1pareto F ms₂merge F (ms₁_1, ms₂) = ms₁m ms₁m ms₁_1 m ms₂

h': List.Mem m ms₁

h: m₁ = m₁ ms₁ = ms₁


h
m ms₁
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: merge F (m₁ :: ms₁, []) = hd :: tl


m m₁ :: ms₁ m []

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

ms₂: List Meas

h_pareto₂: pareto F ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m m₁ :: ms₁ m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom✝: dominates F m₁ m₂ = true


first_dom
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom✝: ¬dominates F m₁ m₂ = true

h_dom✝: dominates F m₂ m₁ = true


second_dom
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₁.last > m₂.last


first_last
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


second_last
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h'✝: List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h'✝: List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h': merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: m₁ = hd merge F (ms₁, List.drop n ms₂) = tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h'✝: List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h': merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: m₁ = hd merge F (ms₁, List.drop n ms₂) = tl

h₁: m₁ = hd

h₂: merge F (ms₁, List.drop n ms₂) = tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)


merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m ms₁


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m ms₁


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m ms₁


h
m m₁ :: ms₁
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m ms₁


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m ms₁


h.a
List.Mem m ms₁
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m ms₁


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


h
m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


h.a
List.Mem m ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


h.a.a
m List.drop ?h.a.n ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


h.a.n
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_dom: dominates F m₁ m₂ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (ms₁, List.drop n ms₂)m merge F (ms₁, List.drop n ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (ms₁, List.drop n ms₂))

h: m₁ = m₁ merge F (ms₁, List.drop n ms₂) = merge F (ms₁, List.drop n ms₂)

h✝: m List.drop n ms₂


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h'✝: List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h'✝: List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: m₂ = hd merge F (List.drop n ms₁, ms₂) = tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h'✝: List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: m₂ = hd merge F (List.drop n ms₁, ms₂) = tl

h₁: m₂ = hd

h₂: merge F (List.drop n ms₁, ms₂) = tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)


merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m ms₂


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


h
m m₁ :: ms₁
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


h.a
List.Mem m ms₁
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


h.a.a
m List.drop ?h.a.n ms₁
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


h.a.n
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m List.drop n ms₁


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m ms₂


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m ms₂


h
m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m ms₂


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m ms₂


h.a
List.Mem m ms₂
α✝: Type

m: Meas

F: Factory α✝

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h'✝: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

ih: ∀ {ms₁_1 ms₂_1 : List Meas}, pareto F ms₁_1pareto F ms₂_1merge F (ms₁_1, ms₂_1) = merge F (List.drop n ms₁, ms₂)m merge F (List.drop n ms₁, ms₂)m ms₁_1 m ms₂_1

h': List.Mem m (merge F (List.drop n ms₁, ms₂))

h: m₂ = m₂ merge F (List.drop n ms₁, ms₂) = merge F (List.drop n ms₁, ms₂)

h✝: m ms₂


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl


merge F (ms₁, m₂ :: ms₂) = tl

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m ms₁


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m m₂ :: ms₂


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m ms₁


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m ms₁


h
m m₁ :: ms₁
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m ms₁


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m ms₁


h.a
List.Mem m ms₁
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m ms₁


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m m₂ :: ms₂


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m m₂ :: ms₂


h
m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h✝: m m₂ :: ms₂


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


¬m₁.last > m₂.last
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


¬m₁.last > m₂.last
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


¬m₁.last > m₂.last
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m₁.last m₂.last
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


¬m₁.last > m₂.last
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


h
m₁.last < m₂.last
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


¬m₁.last > m₂.last

Goals accomplished! 🐙

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl


merge F (m₁ :: ms₁, ms₂) = tl

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m m₁ :: ms₁


inl
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m ms₂


inr
m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m m₁ :: ms₁


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m m₁ :: ms₁


h
m m₁ :: ms₁
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m m₁ :: ms₁


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m ms₂


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m ms₂


h
m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m ms₂


m m₁ :: ms₁ m m₂ :: ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m ms₂


h.a
List.Mem m ms₂
α✝: Type

m: Meas

F: Factory α✝

hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂merge F (ms₁, ms₂) = tlm tlm ms₁ m ms₂

h': List.Mem m tl

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝¹: m₂.last > m₁.last

this: ¬m₁.last > m₂.last

h: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h✝: m ms₂


m m₁ :: ms₁ m m₂ :: ms₂

Goals accomplished! 🐙

Goals accomplished! 🐙
lemma
merge_dom₁: ∀ {α : Type} {F : Factory α} {ms₁ ms₂ : List Meas} {m : Meas}, pareto F ms₁pareto F ms₂m ms₁m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
merge_dom₁
(
h_pareto₁: pareto F ms₁
h_pareto₁
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.82750
F
ms₁: ?m.82757
ms₁
) (
h_pareto₂: pareto F ms₂
h_pareto₂
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.82750
F
ms₂: ?m.82767
ms₂
) (
h: m ms₁
h
:
m: ?m.82793
m
ms₁: ?m.82757
ms₁
) : ∃
m_better: ?m.82834
m_better
,
m_better: ?m.82834
m_better
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.82750
F
ms₁: ?m.82757
ms₁
,
ms₂: ?m.82767
ms₂
⟩ ∧
dominates: {α : Type} → Factory αMeasMeasBool
dominates
F: ?m.82750
F
m_better: ?m.82834
m_better
m: ?m.82793
m
:=

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

rms: List Meas

h_merge: merge F (ms₁, ms₂) = rms


m_better, m_better rms dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

h_merge: merge F (ms₁, ms₂) = []


nil
m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m, head✝: Meas

tail✝: List Meas

tail_ih✝: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tail✝m_better, m_better tail✝ dominates F m_better m = true

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

h_merge: merge F (ms₁, ms₂) = head✝ :: tail✝


cons
m_better, m_better head✝ :: tail✝ dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

h_merge: merge F (ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h_pareto₁: pareto F []

h: m []

h_merge: merge F ([], ms₂) = []


nil
m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

head✝: Meas

tail✝: List Meas

h_pareto₁: pareto F (head✝ :: tail✝)

h: m head✝ :: tail✝

h_merge: merge F (head✝ :: tail✝, ms₂) = []


cons
m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

h_merge: merge F (ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h_pareto₁: pareto F []

h: m []

h_merge: merge F ([], ms₂) = []


m_better, m_better [] dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m: Meas

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

h_merge: merge F (ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = []


merge F (m₁ :: ms₁, ms₂) []
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = []


merge F (m₁ :: ms₁, ms₂) []
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = []


merge F (m₁ :: ms₁, ms₂) []
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = []


h
m₁ :: ms₁ [] ms₂ []
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = []


merge F (m₁ :: ms₁, ms₂) []

Goals accomplished! 🐙

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

h_merge: merge F (ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

h_merge: merge F (ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h_pareto₁: pareto F []

h: m []

h_merge: merge F ([], ms₂) = hd :: tl


nil
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

head✝: Meas

tail✝: List Meas

h_pareto₁: pareto F (head✝ :: tail✝)

h: m head✝ :: tail✝

h_merge: merge F (head✝ :: tail✝, ms₂) = hd :: tl


cons
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

head✝: Meas

tail✝: List Meas

h_pareto₁: pareto F (head✝ :: tail✝)

h: m head✝ :: tail✝

h_merge: merge F (head✝ :: tail✝, ms₂) = hd :: tl


cons
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₁

h_merge: merge F (ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


nil
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

head✝: Meas

tail✝: List Meas

h_pareto₂: pareto F (head✝ :: tail✝)

h_merge: merge F (m₁ :: ms₁, head✝ :: tail✝) = hd :: tl


cons
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


m hd :: tl dominates F m m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


m = hd m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

h_pareto₂: pareto F []

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, []) = hd :: tl


head
m = hd m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl

a✝: List.Mem m ms₁


tail
m = hd m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

h_pareto₂: pareto F []

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, []) = hd :: tl


m = hd m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

h_pareto₂: pareto F []

h_pareto₁: pareto F (m :: ms₁)

h_merge: m = hd ms₁ = tl


m = hd m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

h_pareto₂: pareto F []

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, []) = hd :: tl


m = hd m tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl

h: List.Mem m ms₁


m = hd m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl

h: List.Mem m ms₁


h
m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl

h: List.Mem m ms₁


m = hd m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: List.Mem m ms₁

h_merge: m₁ = hd ms₁ = tl


h
m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl

h: List.Mem m ms₁


m = hd m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h_merge: m₁ = hd ms₁ = tl

h: List.Mem m tl


h
m tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl

h: List.Mem m ms₁


m = hd m tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

h_merge: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom✝: dominates F m₁ m₂ = true


first_dom
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom✝: ¬dominates F m₁ m₂ = true

h_dom✝: dominates F m₂ m₁ = true


second_dom
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₁.last > m₂.last


first_last
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


second_last
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

n:

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m m₂ = true

h': (hd = m tl = merge F (ms₁, List.drop n ms₂)) ∀ (m_1 : Meas), m_1 List.take n ms₂dominates F m m_1 = true


head
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

a✝: List.Mem m ms₁


tail
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

n:

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m m₂ = true

h': (hd = m tl = merge F (ms₁, List.drop n ms₂)) ∀ (m_1 : Meas), m_1 List.take n ms₂dominates F m m_1 = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

n:

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m m₂ = true

h': (hd = m tl = merge F (ms₁, List.drop n ms₂)) ∀ (m_1 : Meas), m_1 List.take n ms₂dominates F m m_1 = true


m hd :: tl dominates F m m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

n:

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m m₂ = true

h': (hd = m tl = merge F (ms₁, List.drop n ms₂)) ∀ (m_1 : Meas), m_1 List.take n ms₂dominates F m m_1 = true


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: List.Mem m ms₁


merge F (ms₁, List.drop n ms₂) = tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih✝: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: List.Mem m ms₁

h_better: Meas

ih: h_better tl dominates F h_better m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih✝: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: List.Mem m ms₁

h_better: Meas

ih: h_better tl dominates F h_better m = true


h_better hd :: tl dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h': (hd = m₁ tl = merge F (ms₁, List.drop n ms₂)) ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_left: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂)

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m m₂ = true

h_dom: dominates F m₂ m = true


head
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

a✝: List.Mem m ms₁


tail
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m m₂ = true

h_dom: dominates F m₂ m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m m₂ = true

h_dom: dominates F m₂ m = true


m₂ hd :: tl dominates F m₂ m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_pareto₁: pareto F (m :: ms₁)

h_merge: merge F (m :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m m₂ = true

h_dom: dominates F m₂ m = true


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: List.Mem m ms₁


m ms₁

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m ms₁


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m ms₁


ms₁ = List.take n ms₁ ++ List.drop n ms₁

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m ms₁

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m List.take n ms₁ ++ List.drop n ms₁

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m ms₁

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m List.take n ms₁ m List.drop n ms₁

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m List.take n ms₁ m List.drop n ms₁

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: m List.take n ms₁ m List.drop n ms₁

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h✝: m List.take n ms₁


inl
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h✝: m List.drop n ms₁


inr
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h: m List.take n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h: m List.take n ms₁


m₂ hd :: tl dominates F m₂ m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h: m List.take n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h: m List.take n ms₁


dominates F m₂ m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h: m List.take n ms₁


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁


merge F (List.drop n ms₁, ms₂) = tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


h_better hd :: tl dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


h_better hd :: tl dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


left
h_better hd :: tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


right
dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


left
h_better hd :: tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


h_better hd :: tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


a
List.Mem h_better tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h_left: hd = m₂ tl = merge F (List.drop n ms₁, ms₂)

h_take_drop: ms₁ = List.take n ms₁ ++ List.drop n ms₁

h_mem: m List.drop n ms₁

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


h_better hd :: tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_pareto₁: pareto F (m :: ms₁)

h_non_dom₁: ¬dominates F m m₂ = true

h_non_dom₂: ¬dominates F m₂ m = true

h_last: m.last > m₂.last

h_merge: m = hd merge F (ms₁, m₂ :: ms₂) = tl


head
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

a✝: List.Mem m ms₁


tail
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_pareto₁: pareto F (m :: ms₁)

h_non_dom₁: ¬dominates F m m₂ = true

h_non_dom₂: ¬dominates F m₂ m = true

h_last: m.last > m₂.last

h_merge: m = hd merge F (ms₁, m₂ :: ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_pareto₁: pareto F (m :: ms₁)

h_non_dom₁: ¬dominates F m m₂ = true

h_non_dom₂: ¬dominates F m₂ m = true

h_last: m.last > m₂.last

h_merge: m = hd merge F (ms₁, m₂ :: ms₂) = tl


m hd :: tl dominates F m m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁: List Meas

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_pareto₁: pareto F (m :: ms₁)

h_non_dom₁: ¬dominates F m m₂ = true

h_non_dom₂: ¬dominates F m₂ m = true

h_last: m.last > m₂.last

h_merge: m = hd merge F (ms₁, m₂ :: ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h_mem: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h_mem: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h_mem: List.Mem m ms₁


merge F (ms₁, m₂ :: ms₂) = tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h_mem: List.Mem m ms₁

m_better: Meas

h: m_better tl dominates F m_better m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h_mem: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h_mem: List.Mem m ms₁

m_better: Meas

h: m_better tl dominates F m_better m = true


m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

h_mem: List.Mem m ms₁


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl


merge F (m₁ :: ms₁, ms₂) = tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h✝: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

m_better: Meas

h: m_better tl dominates F m_better m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h✝: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

m_better: Meas

h: m_better tl dominates F m_better m = true


m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₁merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h: m m₁ :: ms₁

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙

Goals accomplished! 🐙
lemma
merge_dom₂: ∀ {α : Type} {F : Factory α} {ms₁ ms₂ : List Meas} {m : Meas}, pareto F ms₁pareto F ms₂m ms₂m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
merge_dom₂
(
h_pareto₁: pareto F ms₁
h_pareto₁
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.111905
F
ms₁: ?m.111912
ms₁
) (
h_pareto₂: pareto F ms₂
h_pareto₂
:
pareto: {α : Type} → Factory αList MeasProp
pareto
F: ?m.111905
F
ms₂: ?m.111922
ms₂
) (
h: m ms₂
h
:
m: ?m.111948
m
ms₂: ?m.111922
ms₂
) : ∃
m_better: ?m.111989
m_better
,
m_better: ?m.111989
m_better
merge: {α : Type} → Factory αList Meas × List MeasList Meas
merge
F: ?m.111905
F
ms₁: ?m.111912
ms₁
,
ms₂: ?m.111922
ms₂
⟩ ∧
dominates: {α : Type} → Factory αMeasMeasBool
dominates
F: ?m.111905
F
m_better: ?m.111989
m_better
m: ?m.111948
m
:=

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

rms: List Meas

h_merge: merge F (ms₁, ms₂) = rms


m_better, m_better rms dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

h_merge: merge F (ms₁, ms₂) = []


nil
m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m, head✝: Meas

tail✝: List Meas

tail_ih✝: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tail✝m_better, m_better tail✝ dominates F m_better m = true

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

h_merge: merge F (ms₁, ms₂) = head✝ :: tail✝


cons
m_better, m_better head✝ :: tail✝ dominates F m_better m = true
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

h_merge: merge F (ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = []


nil
m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

head✝: Meas

tail✝: List Meas

h_pareto₁: pareto F (head✝ :: tail✝)

h_merge: merge F (head✝ :: tail✝, ms₂) = []


cons
m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

h_merge: merge F (ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: ms₂ = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

h_pareto₁, h_pareto₂: pareto F []

h: m []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = []


m_better, m_better [] dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m: Meas

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

h_merge: merge F (ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = []


merge F (m₁ :: ms₁, ms₂) []
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = []


merge F (m₁ :: ms₁, ms₂) []
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = []


merge F (m₁ :: ms₁, ms₂) []
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = []


h
m₁ :: ms₁ [] ms₂ []
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = []


merge F (m₁ :: ms₁, ms₂) []

Goals accomplished! 🐙

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m: Meas

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = []


m_better, m_better [] dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

ms₁, ms₂: List Meas

m: Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂


m_better, m_better merge F (ms₁, ms₂) dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

h_merge: merge F (ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = hd :: tl


nil
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

head✝: Meas

tail✝: List Meas

h_pareto₁: pareto F (head✝ :: tail✝)

h_merge: merge F (head✝ :: tail✝, ms₂) = hd :: tl


cons
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

h_merge: merge F (ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: ms₂ = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

h_pareto₁: pareto F []

h_pareto₂: pareto F (hd :: tl)

h: m hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

h_pareto₁: pareto F []

h_pareto₂: pareto F (hd :: tl)

h: m hd :: tl


m hd :: tl dominates F m m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

h_pareto₁: pareto F []

h_merge: merge F ([], ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₁, ms₂: List Meas

h_pareto₁: pareto F ms₁

h_pareto₂: pareto F ms₂

h: m ms₂

h_merge: merge F (ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: m []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


nil
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

head✝: Meas

tail✝: List Meas

h_pareto₂: pareto F (head✝ :: tail✝)

h: m head✝ :: tail✝

h_merge: merge F (m₁ :: ms₁, head✝ :: tail✝) = hd :: tl


cons
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_pareto₂: pareto F []

h: m []

h_merge: merge F (m₁ :: ms₁, []) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

ms₂: List Meas

h_pareto₂: pareto F ms₂

h: m ms₂

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

h_merge: merge F (m₁ :: ms₁, ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom✝: dominates F m₁ m₂ = true


first_dom
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom✝: ¬dominates F m₁ m₂ = true

h_dom✝: dominates F m₂ m₁ = true


second_dom
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₁.last > m₂.last


first_last
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h✝: m₂.last > m₁.last


second_last
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_left: merge F (m₁ :: ms₁, m₂ :: ms₂) = m₁ :: merge F (ms₁, List.drop n ms₂)

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_pareto₂: pareto F (m :: ms₂)

h_merge: merge F (m₁ :: ms₁, m :: ms₂) = hd :: tl

h_dom: dominates F m₁ m = true


head
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

a✝: List.Mem m ms₂


tail
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_pareto₂: pareto F (m :: ms₂)

h_merge: merge F (m₁ :: ms₁, m :: ms₂) = hd :: tl

h_dom: dominates F m₁ m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_pareto₂: pareto F (m :: ms₂)

h_merge: merge F (m₁ :: ms₁, m :: ms₂) = hd :: tl

h_dom: dominates F m₁ m = true


m₁ hd :: tl dominates F m₁ m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_pareto₂: pareto F (m :: ms₂)

h_merge: merge F (m₁ :: ms₁, m :: ms₂) = hd :: tl

h_dom: dominates F m₁ m = true


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: List.Mem m ms₂


m ms₂

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m ms₂


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m ms₂


ms₂ = List.take n ms₂ ++ List.drop n ms₂

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m ms₂

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m List.take n ms₂ ++ List.drop n ms₂

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m ms₂

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m List.take n ms₂ m List.drop n ms₂

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m List.take n ms₂ m List.drop n ms₂

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: m List.take n ms₂ m List.drop n ms₂

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h✝: m List.take n ms₂


inl
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h✝: m List.drop n ms₂


inr
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h: m List.take n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h: m List.take n ms₂


m₁ hd :: tl dominates F m₁ m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h: m List.take n ms₂


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂


merge F (ms₁, List.drop n ms₂) = tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


h_better hd :: tl dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


h_better hd :: tl dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


left
h_better hd :: tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


right
dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


left
h_better hd :: tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


h_better hd :: tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


a
List.Mem h_better tl
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_dom: dominates F m₁ m₂ = true

n:

h_right: ∀ (m : Meas), m List.take n ms₂dominates F m₁ m = true

h_left: hd = m₁ tl = merge F (ms₁, List.drop n ms₂)

h_take_drop: ms₂ = List.take n ms₂ ++ List.drop n ms₂

h_mem: m List.drop n ms₂

h_better: Meas

h₁: h_better tl

h₂: dominates F h_better m = true


h_better hd :: tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': merge F (m₁ :: ms₁, m₂ :: ms₂) = m₂ :: merge F (List.drop n ms₁, ms₂) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

n:

h_pareto₂: pareto F (m :: ms₂)

h_merge: merge F (m₁ :: ms₁, m :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m = true

h_dom: dominates F m m₁ = true

h': (hd = m tl = merge F (List.drop n ms₁, ms₂)) ∀ (m_1 : Meas), m_1 List.take n ms₁dominates F m m_1 = true


head
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

a✝: List.Mem m ms₂


tail
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

n:

h_pareto₂: pareto F (m :: ms₂)

h_merge: merge F (m₁ :: ms₁, m :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m = true

h_dom: dominates F m m₁ = true

h': (hd = m tl = merge F (List.drop n ms₁, ms₂)) ∀ (m_1 : Meas), m_1 List.take n ms₁dominates F m m_1 = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

n:

h_pareto₂: pareto F (m :: ms₂)

h_merge: merge F (m₁ :: ms₁, m :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m = true

h_dom: dominates F m m₁ = true

h': (hd = m tl = merge F (List.drop n ms₁, ms₂)) ∀ (m_1 : Meas), m_1 List.take n ms₁dominates F m m_1 = true


m hd :: tl dominates F m m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

n:

h_pareto₂: pareto F (m :: ms₂)

h_merge: merge F (m₁ :: ms₁, m :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m = true

h_dom: dominates F m m₁ = true

h': (hd = m tl = merge F (List.drop n ms₁, ms₂)) ∀ (m_1 : Meas), m_1 List.take n ms₁dominates F m m_1 = true


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: List.Mem m ms₂


merge F (List.drop n ms₁, ms₂) = tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih✝: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: List.Mem m ms₂

h_better: Meas

ih: h_better tl dominates F h_better m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih✝: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: List.Mem m ms₂

h_better: Meas

ih: h_better tl dominates F h_better m = true


h_better hd :: tl dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom: ¬dominates F m₁ m₂ = true

h_dom: dominates F m₂ m₁ = true

n:

h': (hd = m₂ tl = merge F (List.drop n ms₁, ms₂)) ∀ (m : Meas), m List.take n ms₁dominates F m₂ m = true

h: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl


merge F (ms₁, m₂ :: ms₂) = tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h✝: m m₂ :: ms₂

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

m_better: Meas

h: m_better tl dominates F m_better m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h✝: m m₂ :: ms₂

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last

h_merge: m₁ = hd merge F (ms₁, m₂ :: ms₂) = tl

m_better: Meas

h: m_better tl dominates F m_better m = true


m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁: ¬dominates F m₁ m₂ = true

h_non_dom₂: ¬dominates F m₂ m₁ = true

h_last: m₁.last > m₂.last


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

h_pareto₂: pareto F (m :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m = true

h_non_dom₂✝: ¬dominates F m m₁ = true

h_last: ¬m.last < m₁.last

h_merge: m = hd merge F (m₁ :: ms₁, ms₂) = tl


head
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

a✝: List.Mem m ms₂


tail
m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

h_pareto₂: pareto F (m :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m = true

h_non_dom₂✝: ¬dominates F m m₁ = true

h_last: ¬m.last < m₁.last

h_merge: m = hd merge F (m₁ :: ms₁, ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

h_pareto₂: pareto F (m :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m = true

h_non_dom₂✝: ¬dominates F m m₁ = true

h_last: ¬m.last < m₁.last

h_merge: m = hd merge F (m₁ :: ms₁, ms₂) = tl


m hd :: tl dominates F m m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

ms₂: List Meas

h_pareto₂: pareto F (m :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m = true

h_non_dom₂✝: ¬dominates F m m₁ = true

h_last: ¬m.last < m₁.last

h_merge: m = hd merge F (m₁ :: ms₁, ms₂) = tl


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h: m m₂ :: ms₂

h_merge: merge F (m₁ :: ms₁, m₂ :: ms₂) = hd :: tl

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: m₂.last > m₁.last


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h_mem: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h_mem: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h_mem: List.Mem m ms₂


merge F (m₁ :: ms₁, ms₂) = tl

Goals accomplished! 🐙
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h_mem: List.Mem m ms₂

h_better: Meas

h: h_better tl dominates F h_better m = true


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h_mem: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h_mem: List.Mem m ms₂

h_better: Meas

h: h_better tl dominates F h_better m = true


h_better hd :: tl dominates F h_better m = true
α✝: Type

F: Factory α✝

m, hd: Meas

tl: List Meas

ih: ∀ {ms₁ ms₂ : List Meas}, pareto F ms₁pareto F ms₂m ms₂merge F (ms₁, ms₂) = tlm_better, m_better tl dominates F m_better m = true

m₁: Meas

ms₁: List Meas

h_pareto₁: pareto F (m₁ :: ms₁)

m₂: Meas

ms₂: List Meas

h_pareto₂: pareto F (m₂ :: ms₂)

h_non_dom₁✝: ¬dominates F m₁ m₂ = true

h_non_dom₂✝: ¬dominates F m₂ m₁ = true

h_last: ¬m₂.last < m₁.last

h_merge: m₂ = hd merge F (m₁ :: ms₁, ms₂) = tl

h_mem: List.Mem m ms₂


m_better, m_better hd :: tl dominates F m_better m = true

Goals accomplished! 🐙

Goals accomplished! 🐙